package com.example.mediamoudle.scaletime.value

import com.android.baselibrary.app.MainApplication
import com.example.mediamoudle.utlis.dp2px

/**
 * 时间轴共同数据
 */
class TimeLineBaseValue {

    val defaultPx = 50F
    private val frameWidth = MainApplication.mainApplication.dp2px(48f)

    /**
     * 视频总时长
     */
    var duration: Long = 0L

    /**
     *  当前时长：毫秒
     */
    var time: Long = 0L
        set(value) {
            field = when {
                value < 0 -> 0
                value > duration -> duration
                else -> value
            }
        }

    var maxScale = 1.0f
    var minScale = 0.5f//最小是默认的一半，占半屏

    /** 时间轴比例 缩放倍数 */
    var scale: Float = 1.0F
        set(value) {
            field = when {
                value < minScale -> minScale
                value > maxScale -> maxScale
                else -> value
            }
        }

    /** 实际每秒长度对应几像素，会用于分母要保证不会0 */
    var pxInSecond: Float = 1.0F
        private set

    /** 标准一秒几像素 */
    var standPxInSecond: Float = 1.0f
        set(value) {
            field = value
            pxInSecond = field * scale
        }

    /** 时间转成像素 ：单位毫秒 */
    fun time2px(timeMs: Long): Float {
        return timeMs * pxInSecond / 1000
    }

    /** 像素转成时间*/
    fun px2time(px: Float): Long {
        return (px * 1000 / pxInSecond).toLong()
    }

    /** 将时间 -> X坐标
     * @param time 目标时间
     * @param cursorX 竖线（光标）的位置，一般在屏幕中央
     * @param currentTime 光标指向的时间
     * */
    fun time2X(time: Long, cursorX: Int, currentTime: Long = this.time): Float {
        val offsetTime = time - currentTime
        return cursorX + time2px(offsetTime)
    }

    /**
     * 发生缩放后重置标准
     */
    //最小一帧对应的时间，用于直接分割帧，避免缩放的时候产生无数的图片
    var minFrameTime = 250L // frameTime / maxScale

    //最小时间切片的时间
    val minClipTime = MIN_CLIP_TIME
    fun resetStandPxInSecond(holdPxInSecond: Boolean = false) {
        standPxInSecond = MainApplication.mainApplication.dp2px(defaultPx)
        //单段视频是一帧宽48dp 一张图片对应的时间
        val frameTime = frameWidth * 1000 / standPxInSecond
        maxScale = frameTime / minFrameTime //最大精度就是 0.25s 1帧
        minScale = frameWidth * 1000f / duration / standPxInSecond //最小精度为总长度到一帧
        scale = if (holdPxInSecond){
            pxInSecond/standPxInSecond
        }else {
            1.0f
        }
    }
    fun fitScaleForScreen() {
        resetStandPxInSecond(true)
    }

    companion object {
        /**
         * 视频片段最小时间
         */
        const val MIN_CLIP_TIME = 100L
    }

   interface TimeLineBaseView{
       var timeLineValue:TimeLineBaseValue?
       fun scaleChange()
       fun updateTime()
   }
}